home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.5 Applications 2002 November / SGI IRIX 6.5 Applications 2002 November.iso / dev / java2v131_02_dev.idb / usr / java2v131_02 / include / jni.h.z / jni.h
Encoding:
C/C++ Source or Header  |  2002-06-19  |  65.1 KB  |  1,933 lines
  1. /*
  2.  * @(#)jni.h    1.48 00/02/02
  3.  *
  4.  * Copyright 1996-2000 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the proprietary information of Sun Microsystems, Inc.  
  7.  * Use is subject to license terms.
  8.  * 
  9.  */
  10.  
  11. /*
  12.  * We used part of Netscape's Java Runtime Interface (JRI) as the starting
  13.  * point of our design and implementation.
  14.  */
  15.  
  16. /******************************************************************************
  17.  * Java Runtime Interface
  18.  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
  19.  *****************************************************************************/
  20.  
  21. #ifndef _JAVASOFT_JNI_H_
  22. #define _JAVASOFT_JNI_H_
  23.  
  24. #include <stdio.h>
  25. #include <stdarg.h>
  26.  
  27. /* jni_md.h contains the machine-dependent typedefs for jbyte, jint
  28.    and jlong */
  29.  
  30. #include "jni_md.h"
  31.  
  32. #ifdef __cplusplus
  33. extern "C" {
  34. #endif
  35.  
  36. /*
  37.  * JNI Types
  38.  */
  39.  
  40. #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H
  41.  
  42. typedef unsigned char    jboolean;
  43. typedef unsigned short    jchar;
  44. typedef short        jshort;
  45. typedef float        jfloat;
  46. typedef double        jdouble;
  47.  
  48. typedef jint            jsize;
  49.  
  50. #ifdef __cplusplus
  51.  
  52. class _jobject {};
  53. class _jclass : public _jobject {};
  54. class _jthrowable : public _jobject {};
  55. class _jstring : public _jobject {};
  56. class _jarray : public _jobject {};
  57. class _jbooleanArray : public _jarray {};
  58. class _jbyteArray : public _jarray {};
  59. class _jcharArray : public _jarray {};
  60. class _jshortArray : public _jarray {};
  61. class _jintArray : public _jarray {};
  62. class _jlongArray : public _jarray {};
  63. class _jfloatArray : public _jarray {};
  64. class _jdoubleArray : public _jarray {};
  65. class _jobjectArray : public _jarray {};
  66.  
  67. typedef _jobject *jobject;
  68. typedef _jclass *jclass;
  69. typedef _jthrowable *jthrowable;
  70. typedef _jstring *jstring;
  71. typedef _jarray *jarray;
  72. typedef _jbooleanArray *jbooleanArray;
  73. typedef _jbyteArray *jbyteArray;
  74. typedef _jcharArray *jcharArray;
  75. typedef _jshortArray *jshortArray;
  76. typedef _jintArray *jintArray;
  77. typedef _jlongArray *jlongArray;
  78. typedef _jfloatArray *jfloatArray;
  79. typedef _jdoubleArray *jdoubleArray;
  80. typedef _jobjectArray *jobjectArray;
  81.  
  82. #else
  83.  
  84. struct _jobject;
  85.  
  86. typedef struct _jobject *jobject;
  87. typedef jobject jclass;
  88. typedef jobject jthrowable;
  89. typedef jobject jstring;
  90. typedef jobject jarray;
  91. typedef jarray jbooleanArray;
  92. typedef jarray jbyteArray;
  93. typedef jarray jcharArray;
  94. typedef jarray jshortArray;
  95. typedef jarray jintArray;
  96. typedef jarray jlongArray;
  97. typedef jarray jfloatArray;
  98. typedef jarray jdoubleArray;
  99. typedef jarray jobjectArray;
  100.  
  101. #endif
  102.  
  103. typedef jobject jweak;
  104.  
  105. typedef union jvalue {
  106.     jboolean z;
  107.     jbyte    b;
  108.     jchar    c;
  109.     jshort   s;
  110.     jint     i;
  111.     jlong    j;
  112.     jfloat   f;
  113.     jdouble  d;
  114.     jobject  l;
  115. } jvalue;
  116.  
  117. struct _jfieldID;
  118. typedef struct _jfieldID *jfieldID;
  119.  
  120. struct _jmethodID;
  121. typedef struct _jmethodID *jmethodID;
  122.  
  123. #endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */
  124.  
  125. /*
  126.  * jboolean constants
  127.  */
  128.  
  129. #define JNI_FALSE 0
  130. #define JNI_TRUE 1
  131.  
  132. /*
  133.  * possible return values for JNI functions.
  134.  */
  135.  
  136. #define JNI_OK           0                 /* success */
  137. #define JNI_ERR          (-1)              /* unknown error */
  138. #define JNI_EDETACHED    (-2)              /* thread detached from the VM */
  139. #define JNI_EVERSION     (-3)              /* JNI version error */
  140. #define JNI_ENOMEM       (-4)              /* not enough memory */
  141. #define JNI_EEXIST       (-5)              /* VM already created */
  142. #define JNI_EINVAL       (-6)              /* invalid arguments */
  143.  
  144. /*
  145.  * used in ReleaseScalarArrayElements
  146.  */
  147.  
  148. #define JNI_COMMIT 1
  149. #define JNI_ABORT 2
  150.  
  151. /*
  152.  * used in RegisterNatives to describe native method name, signature,
  153.  * and function pointer.
  154.  */
  155.  
  156. typedef struct {
  157.     char *name;
  158.     char *signature;
  159.     void *fnPtr;
  160. } JNINativeMethod;
  161.  
  162. /*
  163.  * JNI Native Method Interface.
  164.  */
  165.  
  166. struct JNINativeInterface_;
  167.  
  168. struct JNIEnv_;
  169.  
  170. #ifdef __cplusplus
  171. typedef JNIEnv_ JNIEnv;
  172. #else
  173. typedef const struct JNINativeInterface_ *JNIEnv;
  174. #endif
  175.  
  176. /*
  177.  * JNI Invocation Interface.
  178.  */
  179.  
  180. struct JNIInvokeInterface_;
  181.  
  182. struct JavaVM_;
  183.  
  184. #ifdef __cplusplus
  185. typedef JavaVM_ JavaVM;
  186. #else
  187. typedef const struct JNIInvokeInterface_ *JavaVM;
  188. #endif
  189.  
  190. struct JNINativeInterface_ {
  191.     void *reserved0;
  192.     void *reserved1;
  193.     void *reserved2;
  194.  
  195.     void *reserved3;
  196.     jint (JNICALL *GetVersion)(JNIEnv *env);
  197.  
  198.     jclass (JNICALL *DefineClass)
  199.       (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
  200.        jsize len);
  201.     jclass (JNICALL *FindClass)
  202.       (JNIEnv *env, const char *name);
  203.  
  204.     jmethodID (JNICALL *FromReflectedMethod)
  205.       (JNIEnv *env, jobject method);
  206.     jfieldID (JNICALL *FromReflectedField)
  207.       (JNIEnv *env, jobject field);
  208.  
  209.     jobject (JNICALL *ToReflectedMethod)
  210.       (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
  211.  
  212.     jclass (JNICALL *GetSuperclass)
  213.       (JNIEnv *env, jclass sub);
  214.     jboolean (JNICALL *IsAssignableFrom)
  215.       (JNIEnv *env, jclass sub, jclass sup);
  216.  
  217.     jobject (JNICALL *ToReflectedField)
  218.       (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
  219.  
  220.     jint (JNICALL *Throw)
  221.       (JNIEnv *env, jthrowable obj);
  222.     jint (JNICALL *ThrowNew)
  223.       (JNIEnv *env, jclass clazz, const char *msg);
  224.     jthrowable (JNICALL *ExceptionOccurred)
  225.       (JNIEnv *env);
  226.     void (JNICALL *ExceptionDescribe)
  227.       (JNIEnv *env);
  228.     void (JNICALL *ExceptionClear)
  229.       (JNIEnv *env);
  230.     void (JNICALL *FatalError)
  231.       (JNIEnv *env, const char *msg);
  232.  
  233.     jint (JNICALL *PushLocalFrame)
  234.       (JNIEnv *env, jint capacity);
  235.     jobject (JNICALL *PopLocalFrame)
  236.       (JNIEnv *env, jobject result);
  237.  
  238.     jobject (JNICALL *NewGlobalRef)
  239.       (JNIEnv *env, jobject lobj);
  240.     void (JNICALL *DeleteGlobalRef)
  241.       (JNIEnv *env, jobject gref);
  242.     void (JNICALL *DeleteLocalRef)
  243.       (JNIEnv *env, jobject obj);
  244.     jboolean (JNICALL *IsSameObject)
  245.       (JNIEnv *env, jobject obj1, jobject obj2);
  246.     jobject (JNICALL *NewLocalRef)
  247.       (JNIEnv *env, jobject ref);
  248.     jint (JNICALL *EnsureLocalCapacity)
  249.       (JNIEnv *env, jint capacity);
  250.  
  251.     jobject (JNICALL *AllocObject)
  252.       (JNIEnv *env, jclass clazz);
  253.     jobject (JNICALL *NewObject)
  254.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  255.     jobject (JNICALL *NewObjectV)
  256.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  257.     jobject (JNICALL *NewObjectA)
  258.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  259.  
  260.     jclass (JNICALL *GetObjectClass)
  261.       (JNIEnv *env, jobject obj);
  262.     jboolean (JNICALL *IsInstanceOf)
  263.       (JNIEnv *env, jobject obj, jclass clazz);
  264.  
  265.     jmethodID (JNICALL *GetMethodID)
  266.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  267.  
  268.     jobject (JNICALL *CallObjectMethod)
  269.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  270.     jobject (JNICALL *CallObjectMethodV)
  271.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  272.     jobject (JNICALL *CallObjectMethodA)
  273.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  274.  
  275.     jboolean (JNICALL *CallBooleanMethod)
  276.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  277.     jboolean (JNICALL *CallBooleanMethodV)
  278.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  279.     jboolean (JNICALL *CallBooleanMethodA)
  280.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  281.  
  282.     jbyte (JNICALL *CallByteMethod)
  283.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  284.     jbyte (JNICALL *CallByteMethodV)
  285.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  286.     jbyte (JNICALL *CallByteMethodA)
  287.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  288.  
  289.     jchar (JNICALL *CallCharMethod)
  290.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  291.     jchar (JNICALL *CallCharMethodV)
  292.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  293.     jchar (JNICALL *CallCharMethodA)
  294.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  295.  
  296.     jshort (JNICALL *CallShortMethod)
  297.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  298.     jshort (JNICALL *CallShortMethodV)
  299.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  300.     jshort (JNICALL *CallShortMethodA)
  301.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  302.  
  303.     jint (JNICALL *CallIntMethod)
  304.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  305.     jint (JNICALL *CallIntMethodV)
  306.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  307.     jint (JNICALL *CallIntMethodA)
  308.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  309.  
  310.     jlong (JNICALL *CallLongMethod)
  311.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  312.     jlong (JNICALL *CallLongMethodV)
  313.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  314.     jlong (JNICALL *CallLongMethodA)
  315.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  316.  
  317.     jfloat (JNICALL *CallFloatMethod)
  318.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  319.     jfloat (JNICALL *CallFloatMethodV)
  320.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  321.     jfloat (JNICALL *CallFloatMethodA)
  322.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  323.  
  324.     jdouble (JNICALL *CallDoubleMethod)
  325.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  326.     jdouble (JNICALL *CallDoubleMethodV)
  327.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  328.     jdouble (JNICALL *CallDoubleMethodA)
  329.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  330.  
  331.     void (JNICALL *CallVoidMethod)
  332.       (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  333.     void (JNICALL *CallVoidMethodV)
  334.       (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  335.     void (JNICALL *CallVoidMethodA)
  336.       (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  337.  
  338.     jobject (JNICALL *CallNonvirtualObjectMethod)
  339.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  340.     jobject (JNICALL *CallNonvirtualObjectMethodV)
  341.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  342.        va_list args);
  343.     jobject (JNICALL *CallNonvirtualObjectMethodA)
  344.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  345.        jvalue * args);
  346.  
  347.     jboolean (JNICALL *CallNonvirtualBooleanMethod)
  348.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  349.     jboolean (JNICALL *CallNonvirtualBooleanMethodV)
  350.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  351.        va_list args);
  352.     jboolean (JNICALL *CallNonvirtualBooleanMethodA)
  353.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  354.        jvalue * args);
  355.  
  356.     jbyte (JNICALL *CallNonvirtualByteMethod)
  357.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  358.     jbyte (JNICALL *CallNonvirtualByteMethodV)
  359.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  360.        va_list args);
  361.     jbyte (JNICALL *CallNonvirtualByteMethodA)
  362.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  363.        jvalue *args);
  364.  
  365.     jchar (JNICALL *CallNonvirtualCharMethod)
  366.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  367.     jchar (JNICALL *CallNonvirtualCharMethodV)
  368.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  369.        va_list args);
  370.     jchar (JNICALL *CallNonvirtualCharMethodA)
  371.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  372.        jvalue *args);
  373.  
  374.     jshort (JNICALL *CallNonvirtualShortMethod)
  375.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  376.     jshort (JNICALL *CallNonvirtualShortMethodV)
  377.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  378.        va_list args);
  379.     jshort (JNICALL *CallNonvirtualShortMethodA)
  380.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  381.        jvalue *args);
  382.  
  383.     jint (JNICALL *CallNonvirtualIntMethod)
  384.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  385.     jint (JNICALL *CallNonvirtualIntMethodV)
  386.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  387.        va_list args);
  388.     jint (JNICALL *CallNonvirtualIntMethodA)
  389.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  390.        jvalue *args);
  391.  
  392.     jlong (JNICALL *CallNonvirtualLongMethod)
  393.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  394.     jlong (JNICALL *CallNonvirtualLongMethodV)
  395.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  396.        va_list args);
  397.     jlong (JNICALL *CallNonvirtualLongMethodA)
  398.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  399.        jvalue *args);
  400.  
  401.     jfloat (JNICALL *CallNonvirtualFloatMethod)
  402.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  403.     jfloat (JNICALL *CallNonvirtualFloatMethodV)
  404.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  405.        va_list args);
  406.     jfloat (JNICALL *CallNonvirtualFloatMethodA)
  407.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  408.        jvalue *args);
  409.  
  410.     jdouble (JNICALL *CallNonvirtualDoubleMethod)
  411.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  412.     jdouble (JNICALL *CallNonvirtualDoubleMethodV)
  413.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  414.        va_list args);
  415.     jdouble (JNICALL *CallNonvirtualDoubleMethodA)
  416.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  417.        jvalue *args);
  418.  
  419.     void (JNICALL *CallNonvirtualVoidMethod)
  420.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  421.     void (JNICALL *CallNonvirtualVoidMethodV)
  422.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  423.        va_list args);
  424.     void (JNICALL *CallNonvirtualVoidMethodA)
  425.       (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  426.        jvalue * args);
  427.  
  428.     jfieldID (JNICALL *GetFieldID)
  429.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  430.  
  431.     jobject (JNICALL *GetObjectField)
  432.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  433.     jboolean (JNICALL *GetBooleanField)
  434.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  435.     jbyte (JNICALL *GetByteField)
  436.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  437.     jchar (JNICALL *GetCharField)
  438.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  439.     jshort (JNICALL *GetShortField)
  440.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  441.     jint (JNICALL *GetIntField)
  442.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  443.     jlong (JNICALL *GetLongField)
  444.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  445.     jfloat (JNICALL *GetFloatField)
  446.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  447.     jdouble (JNICALL *GetDoubleField)
  448.       (JNIEnv *env, jobject obj, jfieldID fieldID);
  449.  
  450.     void (JNICALL *SetObjectField)
  451.       (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
  452.     void (JNICALL *SetBooleanField)
  453.       (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
  454.     void (JNICALL *SetByteField)
  455.       (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
  456.     void (JNICALL *SetCharField)
  457.       (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
  458.     void (JNICALL *SetShortField)
  459.       (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
  460.     void (JNICALL *SetIntField)
  461.       (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
  462.     void (JNICALL *SetLongField)
  463.       (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
  464.     void (JNICALL *SetFloatField)
  465.       (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
  466.     void (JNICALL *SetDoubleField)
  467.       (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
  468.  
  469.     jmethodID (JNICALL *GetStaticMethodID)
  470.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  471.  
  472.     jobject (JNICALL *CallStaticObjectMethod)
  473.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  474.     jobject (JNICALL *CallStaticObjectMethodV)
  475.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  476.     jobject (JNICALL *CallStaticObjectMethodA)
  477.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  478.  
  479.     jboolean (JNICALL *CallStaticBooleanMethod)
  480.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  481.     jboolean (JNICALL *CallStaticBooleanMethodV)
  482.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  483.     jboolean (JNICALL *CallStaticBooleanMethodA)
  484.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  485.  
  486.     jbyte (JNICALL *CallStaticByteMethod)
  487.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  488.     jbyte (JNICALL *CallStaticByteMethodV)
  489.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  490.     jbyte (JNICALL *CallStaticByteMethodA)
  491.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  492.  
  493.     jchar (JNICALL *CallStaticCharMethod)
  494.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  495.     jchar (JNICALL *CallStaticCharMethodV)
  496.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  497.     jchar (JNICALL *CallStaticCharMethodA)
  498.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  499.  
  500.     jshort (JNICALL *CallStaticShortMethod)
  501.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  502.     jshort (JNICALL *CallStaticShortMethodV)
  503.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  504.     jshort (JNICALL *CallStaticShortMethodA)
  505.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  506.  
  507.     jint (JNICALL *CallStaticIntMethod)
  508.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  509.     jint (JNICALL *CallStaticIntMethodV)
  510.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  511.     jint (JNICALL *CallStaticIntMethodA)
  512.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  513.  
  514.     jlong (JNICALL *CallStaticLongMethod)
  515.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  516.     jlong (JNICALL *CallStaticLongMethodV)
  517.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  518.     jlong (JNICALL *CallStaticLongMethodA)
  519.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  520.  
  521.     jfloat (JNICALL *CallStaticFloatMethod)
  522.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  523.     jfloat (JNICALL *CallStaticFloatMethodV)
  524.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  525.     jfloat (JNICALL *CallStaticFloatMethodA)
  526.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  527.  
  528.     jdouble (JNICALL *CallStaticDoubleMethod)
  529.       (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  530.     jdouble (JNICALL *CallStaticDoubleMethodV)
  531.       (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  532.     jdouble (JNICALL *CallStaticDoubleMethodA)
  533.       (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  534.  
  535.     void (JNICALL *CallStaticVoidMethod)
  536.       (JNIEnv *env, jclass cls, jmethodID methodID, ...);
  537.     void (JNICALL *CallStaticVoidMethodV)
  538.       (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
  539.     void (JNICALL *CallStaticVoidMethodA)
  540.       (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
  541.  
  542.     jfieldID (JNICALL *GetStaticFieldID)
  543.       (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  544.     jobject (JNICALL *GetStaticObjectField)
  545.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  546.     jboolean (JNICALL *GetStaticBooleanField)
  547.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  548.     jbyte (JNICALL *GetStaticByteField)
  549.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  550.     jchar (JNICALL *GetStaticCharField)
  551.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  552.     jshort (JNICALL *GetStaticShortField)
  553.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  554.     jint (JNICALL *GetStaticIntField)
  555.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  556.     jlong (JNICALL *GetStaticLongField)
  557.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  558.     jfloat (JNICALL *GetStaticFloatField)
  559.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  560.     jdouble (JNICALL *GetStaticDoubleField)
  561.       (JNIEnv *env, jclass clazz, jfieldID fieldID);
  562.  
  563.     void (JNICALL *SetStaticObjectField)
  564.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
  565.     void (JNICALL *SetStaticBooleanField)
  566.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
  567.     void (JNICALL *SetStaticByteField)
  568.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
  569.     void (JNICALL *SetStaticCharField)
  570.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
  571.     void (JNICALL *SetStaticShortField)
  572.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
  573.     void (JNICALL *SetStaticIntField)
  574.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
  575.     void (JNICALL *SetStaticLongField)
  576.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
  577.     void (JNICALL *SetStaticFloatField)
  578.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
  579.     void (JNICALL *SetStaticDoubleField)
  580.       (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
  581.  
  582.     jstring (JNICALL *NewString)
  583.       (JNIEnv *env, const jchar *unicode, jsize len);
  584.     jsize (JNICALL *GetStringLength)
  585.       (JNIEnv *env, jstring str);
  586.     const jchar *(JNICALL *GetStringChars)
  587.       (JNIEnv *env, jstring str, jboolean *isCopy);
  588.     void (JNICALL *ReleaseStringChars)
  589.       (JNIEnv *env, jstring str, const jchar *chars);
  590.  
  591.     jstring (JNICALL *NewStringUTF)
  592.       (JNIEnv *env, const char *utf);
  593.     jsize (JNICALL *GetStringUTFLength)
  594.       (JNIEnv *env, jstring str);
  595.     const char* (JNICALL *GetStringUTFChars)
  596.       (JNIEnv *env, jstring str, jboolean *isCopy);
  597.     void (JNICALL *ReleaseStringUTFChars)
  598.       (JNIEnv *env, jstring str, const char* chars);
  599.  
  600.  
  601.     jsize (JNICALL *GetArrayLength)
  602.       (JNIEnv *env, jarray array);
  603.  
  604.     jobjectArray (JNICALL *NewObjectArray)
  605.       (JNIEnv *env, jsize len, jclass clazz, jobject init);
  606.     jobject (JNICALL *GetObjectArrayElement)
  607.       (JNIEnv *env, jobjectArray array, jsize index);
  608.     void (JNICALL *SetObjectArrayElement)
  609.       (JNIEnv *env, jobjectArray array, jsize index, jobject val);
  610.  
  611.     jbooleanArray (JNICALL *NewBooleanArray)
  612.       (JNIEnv *env, jsize len);
  613.     jbyteArray (JNICALL *NewByteArray)
  614.       (JNIEnv *env, jsize len);
  615.     jcharArray (JNICALL *NewCharArray)
  616.       (JNIEnv *env, jsize len);
  617.     jshortArray (JNICALL *NewShortArray)
  618.       (JNIEnv *env, jsize len);
  619.     jintArray (JNICALL *NewIntArray)
  620.       (JNIEnv *env, jsize len);
  621.     jlongArray (JNICALL *NewLongArray)
  622.       (JNIEnv *env, jsize len);
  623.     jfloatArray (JNICALL *NewFloatArray)
  624.       (JNIEnv *env, jsize len);
  625.     jdoubleArray (JNICALL *NewDoubleArray)
  626.       (JNIEnv *env, jsize len);
  627.  
  628.     jboolean * (JNICALL *GetBooleanArrayElements)
  629.       (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
  630.     jbyte * (JNICALL *GetByteArrayElements)
  631.       (JNIEnv *env, jbyteArray array, jboolean *isCopy);
  632.     jchar * (JNICALL *GetCharArrayElements)
  633.       (JNIEnv *env, jcharArray array, jboolean *isCopy);
  634.     jshort * (JNICALL *GetShortArrayElements)
  635.       (JNIEnv *env, jshortArray array, jboolean *isCopy);
  636.     jint * (JNICALL *GetIntArrayElements)
  637.       (JNIEnv *env, jintArray array, jboolean *isCopy);
  638.     jlong * (JNICALL *GetLongArrayElements)
  639.       (JNIEnv *env, jlongArray array, jboolean *isCopy);
  640.     jfloat * (JNICALL *GetFloatArrayElements)
  641.       (JNIEnv *env, jfloatArray array, jboolean *isCopy);
  642.     jdouble * (JNICALL *GetDoubleArrayElements)
  643.       (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
  644.  
  645.     void (JNICALL *ReleaseBooleanArrayElements)
  646.       (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
  647.     void (JNICALL *ReleaseByteArrayElements)
  648.       (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
  649.     void (JNICALL *ReleaseCharArrayElements)
  650.       (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
  651.     void (JNICALL *ReleaseShortArrayElements)
  652.       (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
  653.     void (JNICALL *ReleaseIntArrayElements)
  654.       (JNIEnv *env, jintArray array, jint *elems, jint mode);
  655.     void (JNICALL *ReleaseLongArrayElements)
  656.       (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
  657.     void (JNICALL *ReleaseFloatArrayElements)
  658.       (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
  659.     void (JNICALL *ReleaseDoubleArrayElements)
  660.       (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
  661.  
  662.     void (JNICALL *GetBooleanArrayRegion)
  663.       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  664.     void (JNICALL *GetByteArrayRegion)
  665.       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  666.     void (JNICALL *GetCharArrayRegion)
  667.       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  668.     void (JNICALL *GetShortArrayRegion)
  669.       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  670.     void (JNICALL *GetIntArrayRegion)
  671.       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  672.     void (JNICALL *GetLongArrayRegion)
  673.       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  674.     void (JNICALL *GetFloatArrayRegion)
  675.       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  676.     void (JNICALL *GetDoubleArrayRegion)
  677.       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  678.  
  679.     void (JNICALL *SetBooleanArrayRegion)
  680.       (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  681.     void (JNICALL *SetByteArrayRegion)
  682.       (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  683.     void (JNICALL *SetCharArrayRegion)
  684.       (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  685.     void (JNICALL *SetShortArrayRegion)
  686.       (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  687.     void (JNICALL *SetIntArrayRegion)
  688.       (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  689.     void (JNICALL *SetLongArrayRegion)
  690.       (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  691.     void (JNICALL *SetFloatArrayRegion)
  692.       (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  693.     void (JNICALL *SetDoubleArrayRegion)
  694.       (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  695.  
  696.     jint (JNICALL *RegisterNatives)
  697.       (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
  698.        jint nMethods);
  699.     jint (JNICALL *UnregisterNatives)
  700.       (JNIEnv *env, jclass clazz);
  701.  
  702.     jint (JNICALL *MonitorEnter)
  703.       (JNIEnv *env, jobject obj);
  704.     jint (JNICALL *MonitorExit)
  705.       (JNIEnv *env, jobject obj);
  706.  
  707.     jint (JNICALL *GetJavaVM)
  708.       (JNIEnv *env, JavaVM **vm);
  709.  
  710.     void (JNICALL *GetStringRegion)
  711.       (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
  712.     void (JNICALL *GetStringUTFRegion)
  713.       (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
  714.  
  715.     void * (JNICALL *GetPrimitiveArrayCritical)
  716.       (JNIEnv *env, jarray array, jboolean *isCopy);
  717.     void (JNICALL *ReleasePrimitiveArrayCritical)
  718.       (JNIEnv *env, jarray array, void *carray, jint mode);
  719.  
  720.     const jchar * (JNICALL *GetStringCritical)
  721.       (JNIEnv *env, jstring string, jboolean *isCopy);
  722.     void (JNICALL *ReleaseStringCritical)
  723.       (JNIEnv *env, jstring string, const jchar *cstring);
  724.  
  725.     jweak (JNICALL *NewWeakGlobalRef)
  726.        (JNIEnv *env, jobject obj);
  727.     void (JNICALL *DeleteWeakGlobalRef)
  728.        (JNIEnv *env, jweak ref);
  729.  
  730.     jboolean (JNICALL *ExceptionCheck)
  731.        (JNIEnv *env);
  732. };
  733.  
  734. /*
  735.  * We use inlined functions for C++ so that programmers can write:
  736.  *
  737.  *    env->FindClass("java/lang/String")
  738.  *
  739.  * in C++ rather than:
  740.  *
  741.  *    (*env)->FindClass(env, "java/lang/String")
  742.  *
  743.  * in C.
  744.  */
  745.  
  746. struct JNIEnv_ {
  747.     const struct JNINativeInterface_ *functions;
  748. #ifdef __cplusplus
  749.  
  750.     jint GetVersion() {
  751.         return functions->GetVersion(this);
  752.     }
  753.     jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
  754.                jsize len) {
  755.         return functions->DefineClass(this, name, loader, buf, len);
  756.     }
  757.     jclass FindClass(const char *name) {
  758.         return functions->FindClass(this, name);
  759.     }
  760.     jmethodID FromReflectedMethod(jobject method) {
  761.         return functions->FromReflectedMethod(this,method);
  762.     }
  763.     jfieldID FromReflectedField(jobject field) {
  764.         return functions->FromReflectedField(this,field);
  765.     }
  766.  
  767.     jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
  768.         return functions->ToReflectedMethod(this, cls, methodID, isStatic);
  769.     }
  770.  
  771.     jclass GetSuperclass(jclass sub) {
  772.         return functions->GetSuperclass(this, sub);
  773.     }
  774.     jboolean IsAssignableFrom(jclass sub, jclass sup) {
  775.         return functions->IsAssignableFrom(this, sub, sup);
  776.     }
  777.  
  778.     jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
  779.         return functions->ToReflectedField(this,cls,fieldID,isStatic);
  780.     }
  781.  
  782.     jint Throw(jthrowable obj) {
  783.         return functions->Throw(this, obj);
  784.     }
  785.     jint ThrowNew(jclass clazz, const char *msg) {
  786.         return functions->ThrowNew(this, clazz, msg);
  787.     }
  788.     jthrowable ExceptionOccurred() {
  789.         return functions->ExceptionOccurred(this);
  790.     }
  791.     void ExceptionDescribe() {
  792.         functions->ExceptionDescribe(this);
  793.     }
  794.     void ExceptionClear() {
  795.         functions->ExceptionClear(this);
  796.     }
  797.     void FatalError(const char *msg) {
  798.         functions->FatalError(this, msg);
  799.     }
  800.  
  801.     jint PushLocalFrame(jint capacity) {
  802.         return functions->PushLocalFrame(this,capacity);
  803.     }
  804.     jobject PopLocalFrame(jobject result) {
  805.         return functions->PopLocalFrame(this,result);
  806.     }
  807.  
  808.     jobject NewGlobalRef(jobject lobj) {
  809.         return functions->NewGlobalRef(this,lobj);
  810.     }
  811.     void DeleteGlobalRef(jobject gref) {
  812.         functions->DeleteGlobalRef(this,gref);
  813.     }
  814.     void DeleteLocalRef(jobject obj) {
  815.         functions->DeleteLocalRef(this, obj);
  816.     }
  817.  
  818.     jboolean IsSameObject(jobject obj1, jobject obj2) {
  819.         return functions->IsSameObject(this,obj1,obj2);
  820.     }
  821.  
  822.     jobject NewLocalRef(jobject ref) {
  823.         return functions->NewLocalRef(this,ref);
  824.     }
  825.     jint EnsureLocalCapacity(jint capacity) {
  826.         return functions->EnsureLocalCapacity(this,capacity);
  827.     }
  828.  
  829.     jobject AllocObject(jclass clazz) {
  830.         return functions->AllocObject(this,clazz);
  831.     }
  832.     jobject NewObject(jclass clazz, jmethodID methodID, ...) {
  833.         va_list args;
  834.     jobject result;
  835.     va_start(args, methodID);
  836.         result = functions->NewObjectV(this,clazz,methodID,args);
  837.     va_end(args);
  838.     return result;
  839.     }
  840.     jobject NewObjectV(jclass clazz, jmethodID methodID,
  841.                va_list args) {
  842.         return functions->NewObjectV(this,clazz,methodID,args);
  843.     }
  844.     jobject NewObjectA(jclass clazz, jmethodID methodID,
  845.                jvalue *args) {
  846.         return functions->NewObjectA(this,clazz,methodID,args);
  847.     }
  848.  
  849.     jclass GetObjectClass(jobject obj) {
  850.         return functions->GetObjectClass(this,obj);
  851.     }
  852.     jboolean IsInstanceOf(jobject obj, jclass clazz) {
  853.         return functions->IsInstanceOf(this,obj,clazz);
  854.     }
  855.  
  856.     jmethodID GetMethodID(jclass clazz, const char *name,
  857.               const char *sig) {
  858.         return functions->GetMethodID(this,clazz,name,sig);
  859.     }
  860.  
  861.     jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
  862.         va_list args;
  863.     jobject result;
  864.     va_start(args,methodID);
  865.     result = functions->CallObjectMethodV(this,obj,methodID,args);
  866.     va_end(args);
  867.     return result;
  868.     }
  869.     jobject CallObjectMethodV(jobject obj, jmethodID methodID,
  870.             va_list args) {
  871.         return functions->CallObjectMethodV(this,obj,methodID,args);
  872.     }
  873.     jobject CallObjectMethodA(jobject obj, jmethodID methodID,
  874.             jvalue * args) {
  875.         return functions->CallObjectMethodA(this,obj,methodID,args);
  876.     }
  877.  
  878.     jboolean CallBooleanMethod(jobject obj,
  879.                    jmethodID methodID, ...) {
  880.         va_list args;
  881.     jboolean result;
  882.     va_start(args,methodID);
  883.     result = functions->CallBooleanMethodV(this,obj,methodID,args);
  884.     va_end(args);
  885.     return result;
  886.     }
  887.     jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
  888.                 va_list args) {
  889.         return functions->CallBooleanMethodV(this,obj,methodID,args);
  890.     }
  891.     jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
  892.                 jvalue * args) {
  893.         return functions->CallBooleanMethodA(this,obj,methodID, args);
  894.     }
  895.  
  896.     jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
  897.         va_list args;
  898.     jbyte result;
  899.     va_start(args,methodID);
  900.     result = functions->CallByteMethodV(this,obj,methodID,args);
  901.     va_end(args);
  902.     return result;
  903.     }
  904.     jbyte CallByteMethodV(jobject obj, jmethodID methodID,
  905.               va_list args) {
  906.         return functions->CallByteMethodV(this,obj,methodID,args);
  907.     }
  908.     jbyte CallByteMethodA(jobject obj, jmethodID methodID,
  909.               jvalue * args) {
  910.         return functions->CallByteMethodA(this,obj,methodID,args);
  911.     }
  912.  
  913.     jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
  914.         va_list args;
  915.     jchar result;
  916.     va_start(args,methodID);
  917.     result = functions->CallCharMethodV(this,obj,methodID,args);
  918.     va_end(args);
  919.     return result;
  920.     }
  921.     jchar CallCharMethodV(jobject obj, jmethodID methodID,
  922.               va_list args) {
  923.         return functions->CallCharMethodV(this,obj,methodID,args);
  924.     }
  925.     jchar CallCharMethodA(jobject obj, jmethodID methodID,
  926.               jvalue * args) {
  927.         return functions->CallCharMethodA(this,obj,methodID,args);
  928.     }
  929.  
  930.     jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
  931.         va_list args;
  932.     jshort result;
  933.     va_start(args,methodID);
  934.     result = functions->CallShortMethodV(this,obj,methodID,args);
  935.     va_end(args);
  936.     return result;
  937.     }
  938.     jshort CallShortMethodV(jobject obj, jmethodID methodID,
  939.                 va_list args) {
  940.         return functions->CallShortMethodV(this,obj,methodID,args);
  941.     }
  942.     jshort CallShortMethodA(jobject obj, jmethodID methodID,
  943.                 jvalue * args) {
  944.         return functions->CallShortMethodA(this,obj,methodID,args);
  945.     }
  946.  
  947.     jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
  948.         va_list args;
  949.     jint result;
  950.     va_start(args,methodID);
  951.     result = functions->CallIntMethodV(this,obj,methodID,args);
  952.     va_end(args);
  953.     return result;
  954.     }
  955.     jint CallIntMethodV(jobject obj, jmethodID methodID,
  956.             va_list args) {
  957.         return functions->CallIntMethodV(this,obj,methodID,args);
  958.     }
  959.     jint CallIntMethodA(jobject obj, jmethodID methodID,
  960.             jvalue * args) {
  961.         return functions->CallIntMethodA(this,obj,methodID,args);
  962.     }
  963.  
  964.     jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
  965.         va_list args;
  966.     jlong result;
  967.     va_start(args,methodID);
  968.     result = functions->CallLongMethodV(this,obj,methodID,args);
  969.     va_end(args);
  970.     return result;
  971.     }
  972.     jlong CallLongMethodV(jobject obj, jmethodID methodID,
  973.               va_list args) {
  974.         return functions->CallLongMethodV(this,obj,methodID,args);
  975.     }
  976.     jlong CallLongMethodA(jobject obj, jmethodID methodID,
  977.               jvalue * args) {
  978.         return functions->CallLongMethodA(this,obj,methodID,args);
  979.     }
  980.  
  981.     jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
  982.         va_list args;
  983.     jfloat result;
  984.     va_start(args,methodID);
  985.     result = functions->CallFloatMethodV(this,obj,methodID,args);
  986.     va_end(args);
  987.     return result;
  988.     }
  989.     jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
  990.                 va_list args) {
  991.         return functions->CallFloatMethodV(this,obj,methodID,args);
  992.     }
  993.     jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
  994.                 jvalue * args) {
  995.         return functions->CallFloatMethodA(this,obj,methodID,args);
  996.     }
  997.  
  998.     jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
  999.         va_list args;
  1000.     jdouble result;
  1001.     va_start(args,methodID);
  1002.     result = functions->CallDoubleMethodV(this,obj,methodID,args);
  1003.     va_end(args);
  1004.     return result;
  1005.     }
  1006.     jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
  1007.             va_list args) {
  1008.         return functions->CallDoubleMethodV(this,obj,methodID,args);
  1009.     }
  1010.     jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
  1011.             jvalue * args) {
  1012.         return functions->CallDoubleMethodA(this,obj,methodID,args);
  1013.     }
  1014.  
  1015.     void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
  1016.         va_list args;
  1017.     va_start(args,methodID);
  1018.     functions->CallVoidMethodV(this,obj,methodID,args);
  1019.     va_end(args);
  1020.     }
  1021.     void CallVoidMethodV(jobject obj, jmethodID methodID,
  1022.              va_list args) {
  1023.         functions->CallVoidMethodV(this,obj,methodID,args);
  1024.     }
  1025.     void CallVoidMethodA(jobject obj, jmethodID methodID,
  1026.              jvalue * args) {
  1027.         functions->CallVoidMethodA(this,obj,methodID,args);
  1028.     }
  1029.  
  1030.     jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
  1031.                        jmethodID methodID, ...) {
  1032.         va_list args;
  1033.     jobject result;
  1034.     va_start(args,methodID);
  1035.     result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  1036.                             methodID,args);
  1037.     va_end(args);
  1038.     return result;
  1039.     }
  1040.     jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
  1041.                     jmethodID methodID, va_list args) {
  1042.         return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  1043.                               methodID,args);
  1044.     }
  1045.     jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
  1046.                     jmethodID methodID, jvalue * args) {
  1047.         return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
  1048.                               methodID,args);
  1049.     }
  1050.  
  1051.     jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
  1052.                      jmethodID methodID, ...) {
  1053.         va_list args;
  1054.     jboolean result;
  1055.     va_start(args,methodID);
  1056.     result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  1057.                              methodID,args);
  1058.     va_end(args);
  1059.     return result;
  1060.     }
  1061.     jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
  1062.                       jmethodID methodID, va_list args) {
  1063.         return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  1064.                                methodID,args);
  1065.     }
  1066.     jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
  1067.                       jmethodID methodID, jvalue * args) {
  1068.         return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
  1069.                                methodID, args);
  1070.     }
  1071.  
  1072.     jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
  1073.                    jmethodID methodID, ...) {
  1074.         va_list args;
  1075.     jbyte result;
  1076.     va_start(args,methodID);
  1077.     result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
  1078.                               methodID,args);
  1079.     va_end(args);
  1080.     return result;
  1081.     }
  1082.     jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
  1083.                     jmethodID methodID, va_list args) {
  1084.         return functions->CallNonvirtualByteMethodV(this,obj,clazz,
  1085.                             methodID,args);
  1086.     }
  1087.     jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
  1088.                     jmethodID methodID, jvalue * args) {
  1089.         return functions->CallNonvirtualByteMethodA(this,obj,clazz,
  1090.                             methodID,args);
  1091.     }
  1092.  
  1093.     jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
  1094.                    jmethodID methodID, ...) {
  1095.         va_list args;
  1096.     jchar result;
  1097.     va_start(args,methodID);
  1098.     result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
  1099.                               methodID,args);
  1100.     va_end(args);
  1101.     return result;
  1102.     }
  1103.     jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
  1104.                     jmethodID methodID, va_list args) {
  1105.         return functions->CallNonvirtualCharMethodV(this,obj,clazz,
  1106.                             methodID,args);
  1107.     }
  1108.     jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
  1109.                     jmethodID methodID, jvalue * args) {
  1110.         return functions->CallNonvirtualCharMethodA(this,obj,clazz,
  1111.                             methodID,args);
  1112.     }
  1113.  
  1114.     jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
  1115.                      jmethodID methodID, ...) {
  1116.         va_list args;
  1117.     jshort result;
  1118.     va_start(args,methodID);
  1119.     result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1120.                                methodID,args);
  1121.     va_end(args);
  1122.     return result;
  1123.     }
  1124.     jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
  1125.                       jmethodID methodID, va_list args) {
  1126.         return functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1127.                              methodID,args);
  1128.     }
  1129.     jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
  1130.                       jmethodID methodID, jvalue * args) {
  1131.         return functions->CallNonvirtualShortMethodA(this,obj,clazz,
  1132.                              methodID,args);
  1133.     }
  1134.  
  1135.     jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
  1136.                  jmethodID methodID, ...) {
  1137.         va_list args;
  1138.     jint result;
  1139.     va_start(args,methodID);
  1140.     result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1141.                              methodID,args);
  1142.     va_end(args);
  1143.     return result;
  1144.     }
  1145.     jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
  1146.                   jmethodID methodID, va_list args) {
  1147.         return functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1148.                            methodID,args);
  1149.     }
  1150.     jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
  1151.                   jmethodID methodID, jvalue * args) {
  1152.         return functions->CallNonvirtualIntMethodA(this,obj,clazz,
  1153.                            methodID,args);
  1154.     }
  1155.  
  1156.     jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
  1157.                    jmethodID methodID, ...) {
  1158.         va_list args;
  1159.     jlong result;
  1160.     va_start(args,methodID);
  1161.     result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1162.                               methodID,args);
  1163.     va_end(args);
  1164.     return result;
  1165.     }
  1166.     jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
  1167.                     jmethodID methodID, va_list args) {
  1168.         return functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1169.                             methodID,args);
  1170.     }
  1171.     jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
  1172.                     jmethodID methodID, jvalue * args) {
  1173.         return functions->CallNonvirtualLongMethodA(this,obj,clazz,
  1174.                             methodID,args);
  1175.     }
  1176.  
  1177.     jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
  1178.                      jmethodID methodID, ...) {
  1179.         va_list args;
  1180.     jfloat result;
  1181.     va_start(args,methodID);
  1182.     result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1183.                                methodID,args);
  1184.     va_end(args);
  1185.     return result;
  1186.     }
  1187.     jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
  1188.                       jmethodID methodID,
  1189.                       va_list args) {
  1190.         return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1191.                              methodID,args);
  1192.     }
  1193.     jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
  1194.                       jmethodID methodID,
  1195.                       jvalue * args) {
  1196.         return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
  1197.                              methodID,args);
  1198.     }
  1199.  
  1200.     jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
  1201.                        jmethodID methodID, ...) {
  1202.         va_list args;
  1203.     jdouble result;
  1204.     va_start(args,methodID);
  1205.     result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1206.                             methodID,args);
  1207.     va_end(args);
  1208.     return result;
  1209.     }
  1210.     jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
  1211.                     jmethodID methodID,
  1212.                     va_list args) {
  1213.         return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1214.                               methodID,args);
  1215.     }
  1216.     jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
  1217.                     jmethodID methodID,
  1218.                     jvalue * args) {
  1219.         return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
  1220.                               methodID,args);
  1221.     }
  1222.  
  1223.     void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
  1224.                   jmethodID methodID, ...) {
  1225.         va_list args;
  1226.     va_start(args,methodID);
  1227.     functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1228.     va_end(args);
  1229.     }
  1230.     void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
  1231.                    jmethodID methodID,
  1232.                    va_list args) {
  1233.         functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1234.     }
  1235.     void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
  1236.                    jmethodID methodID,
  1237.                    jvalue * args) {
  1238.         functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
  1239.     }
  1240.  
  1241.     jfieldID GetFieldID(jclass clazz, const char *name,
  1242.             const char *sig) {
  1243.         return functions->GetFieldID(this,clazz,name,sig);
  1244.     }
  1245.  
  1246.     jobject GetObjectField(jobject obj, jfieldID fieldID) {
  1247.         return functions->GetObjectField(this,obj,fieldID);
  1248.     }
  1249.     jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
  1250.         return functions->GetBooleanField(this,obj,fieldID);
  1251.     }
  1252.     jbyte GetByteField(jobject obj, jfieldID fieldID) {
  1253.         return functions->GetByteField(this,obj,fieldID);
  1254.     }
  1255.     jchar GetCharField(jobject obj, jfieldID fieldID) {
  1256.         return functions->GetCharField(this,obj,fieldID);
  1257.     }
  1258.     jshort GetShortField(jobject obj, jfieldID fieldID) {
  1259.         return functions->GetShortField(this,obj,fieldID);
  1260.     }
  1261.     jint GetIntField(jobject obj, jfieldID fieldID) {
  1262.         return functions->GetIntField(this,obj,fieldID);
  1263.     }
  1264.     jlong GetLongField(jobject obj, jfieldID fieldID) {
  1265.         return functions->GetLongField(this,obj,fieldID);
  1266.     }
  1267.     jfloat GetFloatField(jobject obj, jfieldID fieldID) {
  1268.         return functions->GetFloatField(this,obj,fieldID);
  1269.     }
  1270.     jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
  1271.         return functions->GetDoubleField(this,obj,fieldID);
  1272.     }
  1273.  
  1274.     void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
  1275.         functions->SetObjectField(this,obj,fieldID,val);
  1276.     }
  1277.     void SetBooleanField(jobject obj, jfieldID fieldID,
  1278.              jboolean val) {
  1279.         functions->SetBooleanField(this,obj,fieldID,val);
  1280.     }
  1281.     void SetByteField(jobject obj, jfieldID fieldID,
  1282.               jbyte val) {
  1283.         functions->SetByteField(this,obj,fieldID,val);
  1284.     }
  1285.     void SetCharField(jobject obj, jfieldID fieldID,
  1286.               jchar val) {
  1287.         functions->SetCharField(this,obj,fieldID,val);
  1288.     }
  1289.     void SetShortField(jobject obj, jfieldID fieldID,
  1290.                jshort val) {
  1291.         functions->SetShortField(this,obj,fieldID,val);
  1292.     }
  1293.     void SetIntField(jobject obj, jfieldID fieldID,
  1294.              jint val) {
  1295.         functions->SetIntField(this,obj,fieldID,val);
  1296.     }
  1297.     void SetLongField(jobject obj, jfieldID fieldID,
  1298.               jlong val) {
  1299.         functions->SetLongField(this,obj,fieldID,val);
  1300.     }
  1301.     void SetFloatField(jobject obj, jfieldID fieldID,
  1302.                jfloat val) {
  1303.         functions->SetFloatField(this,obj,fieldID,val);
  1304.     }
  1305.     void SetDoubleField(jobject obj, jfieldID fieldID,
  1306.             jdouble val) {
  1307.         functions->SetDoubleField(this,obj,fieldID,val);
  1308.     }
  1309.  
  1310.     jmethodID GetStaticMethodID(jclass clazz, const char *name,
  1311.                 const char *sig) {
  1312.         return functions->GetStaticMethodID(this,clazz,name,sig);
  1313.     }
  1314.  
  1315.     jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
  1316.                  ...) {
  1317.         va_list args;
  1318.     jobject result;
  1319.     va_start(args,methodID);
  1320.     result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1321.     va_end(args);
  1322.     return result;
  1323.     }
  1324.     jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
  1325.                   va_list args) {
  1326.         return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1327.     }
  1328.     jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
  1329.                   jvalue *args) {
  1330.         return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
  1331.     }
  1332.  
  1333.     jboolean CallStaticBooleanMethod(jclass clazz,
  1334.                      jmethodID methodID, ...) {
  1335.         va_list args;
  1336.     jboolean result;
  1337.     va_start(args,methodID);
  1338.     result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1339.     va_end(args);
  1340.     return result;
  1341.     }
  1342.     jboolean CallStaticBooleanMethodV(jclass clazz,
  1343.                       jmethodID methodID, va_list args) {
  1344.         return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1345.     }
  1346.     jboolean CallStaticBooleanMethodA(jclass clazz,
  1347.                       jmethodID methodID, jvalue *args) {
  1348.         return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
  1349.     }
  1350.  
  1351.     jbyte CallStaticByteMethod(jclass clazz,
  1352.                    jmethodID methodID, ...) {
  1353.         va_list args;
  1354.     jbyte result;
  1355.     va_start(args,methodID);
  1356.     result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1357.     va_end(args);
  1358.     return result;
  1359.     }
  1360.     jbyte CallStaticByteMethodV(jclass clazz,
  1361.                 jmethodID methodID, va_list args) {
  1362.         return functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1363.     }
  1364.     jbyte CallStaticByteMethodA(jclass clazz,
  1365.                 jmethodID methodID, jvalue *args) {
  1366.         return functions->CallStaticByteMethodA(this,clazz,methodID,args);
  1367.     }
  1368.  
  1369.     jchar CallStaticCharMethod(jclass clazz,
  1370.                    jmethodID methodID, ...) {
  1371.         va_list args;
  1372.     jchar result;
  1373.     va_start(args,methodID);
  1374.     result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1375.     va_end(args);
  1376.     return result;
  1377.     }
  1378.     jchar CallStaticCharMethodV(jclass clazz,
  1379.                 jmethodID methodID, va_list args) {
  1380.         return functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1381.     }
  1382.     jchar CallStaticCharMethodA(jclass clazz,
  1383.                 jmethodID methodID, jvalue *args) {
  1384.         return functions->CallStaticCharMethodA(this,clazz,methodID,args);
  1385.     }
  1386.  
  1387.     jshort CallStaticShortMethod(jclass clazz,
  1388.                  jmethodID methodID, ...) {
  1389.         va_list args;
  1390.     jshort result;
  1391.     va_start(args,methodID);
  1392.     result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1393.     va_end(args);
  1394.     return result;
  1395.     }
  1396.     jshort CallStaticShortMethodV(jclass clazz,
  1397.                   jmethodID methodID, va_list args) {
  1398.         return functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1399.     }
  1400.     jshort CallStaticShortMethodA(jclass clazz,
  1401.                   jmethodID methodID, jvalue *args) {
  1402.         return functions->CallStaticShortMethodA(this,clazz,methodID,args);
  1403.     }
  1404.  
  1405.     jint CallStaticIntMethod(jclass clazz,
  1406.                  jmethodID methodID, ...) {
  1407.         va_list args;
  1408.     jint result;
  1409.     va_start(args,methodID);
  1410.     result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1411.     va_end(args);
  1412.     return result;
  1413.     }
  1414.     jint CallStaticIntMethodV(jclass clazz,
  1415.                   jmethodID methodID, va_list args) {
  1416.         return functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1417.     }
  1418.     jint CallStaticIntMethodA(jclass clazz,
  1419.                   jmethodID methodID, jvalue *args) {
  1420.         return functions->CallStaticIntMethodA(this,clazz,methodID,args);
  1421.     }
  1422.  
  1423.     jlong CallStaticLongMethod(jclass clazz,
  1424.                    jmethodID methodID, ...) {
  1425.         va_list args;
  1426.     jlong result;
  1427.     va_start(args,methodID);
  1428.     result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1429.     va_end(args);
  1430.     return result;
  1431.     }
  1432.     jlong CallStaticLongMethodV(jclass clazz,
  1433.                 jmethodID methodID, va_list args) {
  1434.         return functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1435.     }
  1436.     jlong CallStaticLongMethodA(jclass clazz,
  1437.                 jmethodID methodID, jvalue *args) {
  1438.         return functions->CallStaticLongMethodA(this,clazz,methodID,args);
  1439.     }
  1440.  
  1441.     jfloat CallStaticFloatMethod(jclass clazz,
  1442.                  jmethodID methodID, ...) {
  1443.         va_list args;
  1444.     jfloat result;
  1445.     va_start(args,methodID);
  1446.     result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1447.     va_end(args);
  1448.     return result;
  1449.     }
  1450.     jfloat CallStaticFloatMethodV(jclass clazz,
  1451.                   jmethodID methodID, va_list args) {
  1452.         return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1453.     }
  1454.     jfloat CallStaticFloatMethodA(jclass clazz,
  1455.                   jmethodID methodID, jvalue *args) {
  1456.         return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
  1457.     }
  1458.  
  1459.     jdouble CallStaticDoubleMethod(jclass clazz,
  1460.                    jmethodID methodID, ...) {
  1461.         va_list args;
  1462.     jdouble result;
  1463.     va_start(args,methodID);
  1464.     result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1465.     va_end(args);
  1466.     return result;
  1467.     }
  1468.     jdouble CallStaticDoubleMethodV(jclass clazz,
  1469.                     jmethodID methodID, va_list args) {
  1470.         return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1471.     }
  1472.     jdouble CallStaticDoubleMethodA(jclass clazz,
  1473.                     jmethodID methodID, jvalue *args) {
  1474.         return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
  1475.     }
  1476.  
  1477.     void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
  1478.         va_list args;
  1479.     va_start(args,methodID);
  1480.     functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1481.     va_end(args);
  1482.     }
  1483.     void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
  1484.                    va_list args) {
  1485.         functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1486.     }
  1487.     void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
  1488.                    jvalue * args) {
  1489.         functions->CallStaticVoidMethodA(this,cls,methodID,args);
  1490.     }
  1491.  
  1492.     jfieldID GetStaticFieldID(jclass clazz, const char *name,
  1493.                   const char *sig) {
  1494.         return functions->GetStaticFieldID(this,clazz,name,sig);
  1495.     }
  1496.     jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
  1497.         return functions->GetStaticObjectField(this,clazz,fieldID);
  1498.     }
  1499.     jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
  1500.         return functions->GetStaticBooleanField(this,clazz,fieldID);
  1501.     }
  1502.     jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
  1503.         return functions->GetStaticByteField(this,clazz,fieldID);
  1504.     }
  1505.     jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
  1506.         return functions->GetStaticCharField(this,clazz,fieldID);
  1507.     }
  1508.     jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
  1509.         return functions->GetStaticShortField(this,clazz,fieldID);
  1510.     }
  1511.     jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
  1512.         return functions->GetStaticIntField(this,clazz,fieldID);
  1513.     }
  1514.     jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
  1515.         return functions->GetStaticLongField(this,clazz,fieldID);
  1516.     }
  1517.     jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
  1518.         return functions->GetStaticFloatField(this,clazz,fieldID);
  1519.     }
  1520.     jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
  1521.         return functions->GetStaticDoubleField(this,clazz,fieldID);
  1522.     }
  1523.  
  1524.     void SetStaticObjectField(jclass clazz, jfieldID fieldID,
  1525.             jobject value) {
  1526.       functions->SetStaticObjectField(this,clazz,fieldID,value);
  1527.     }
  1528.     void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
  1529.             jboolean value) {
  1530.       functions->SetStaticBooleanField(this,clazz,fieldID,value);
  1531.     }
  1532.     void SetStaticByteField(jclass clazz, jfieldID fieldID,
  1533.             jbyte value) {
  1534.       functions->SetStaticByteField(this,clazz,fieldID,value);
  1535.     }
  1536.     void SetStaticCharField(jclass clazz, jfieldID fieldID,
  1537.             jchar value) {
  1538.       functions->SetStaticCharField(this,clazz,fieldID,value);
  1539.     }
  1540.     void SetStaticShortField(jclass clazz, jfieldID fieldID,
  1541.             jshort value) {
  1542.       functions->SetStaticShortField(this,clazz,fieldID,value);
  1543.     }
  1544.     void SetStaticIntField(jclass clazz, jfieldID fieldID,
  1545.             jint value) {
  1546.       functions->SetStaticIntField(this,clazz,fieldID,value);
  1547.     }
  1548.     void SetStaticLongField(jclass clazz, jfieldID fieldID,
  1549.             jlong value) {
  1550.       functions->SetStaticLongField(this,clazz,fieldID,value);
  1551.     }
  1552.     void SetStaticFloatField(jclass clazz, jfieldID fieldID,
  1553.             jfloat value) {
  1554.       functions->SetStaticFloatField(this,clazz,fieldID,value);
  1555.     }
  1556.     void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
  1557.             jdouble value) {
  1558.       functions->SetStaticDoubleField(this,clazz,fieldID,value);
  1559.     }
  1560.  
  1561.     jstring NewString(const jchar *unicode, jsize len) {
  1562.         return functions->NewString(this,unicode,len);
  1563.     }
  1564.     jsize GetStringLength(jstring str) {
  1565.         return functions->GetStringLength(this,str);
  1566.     }
  1567.     const jchar *GetStringChars(jstring str, jboolean *isCopy) {
  1568.         return functions->GetStringChars(this,str,isCopy);
  1569.     }
  1570.     void ReleaseStringChars(jstring str, const jchar *chars) {
  1571.         functions->ReleaseStringChars(this,str,chars);
  1572.     }
  1573.  
  1574.     jstring NewStringUTF(const char *utf) {
  1575.         return functions->NewStringUTF(this,utf);
  1576.     }
  1577.     jsize GetStringUTFLength(jstring str) {
  1578.         return functions->GetStringUTFLength(this,str);
  1579.     }
  1580.     const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
  1581.         return functions->GetStringUTFChars(this,str,isCopy);
  1582.     }
  1583.     void ReleaseStringUTFChars(jstring str, const char* chars) {
  1584.         functions->ReleaseStringUTFChars(this,str,chars);
  1585.     }
  1586.  
  1587.     jsize GetArrayLength(jarray array) {
  1588.         return functions->GetArrayLength(this,array);
  1589.     }
  1590.  
  1591.     jobjectArray NewObjectArray(jsize len, jclass clazz,
  1592.                 jobject init) {
  1593.         return functions->NewObjectArray(this,len,clazz,init);
  1594.     }
  1595.     jobject GetObjectArrayElement(jobjectArray array, jsize index) {
  1596.         return functions->GetObjectArrayElement(this,array,index);
  1597.     }
  1598.     void SetObjectArrayElement(jobjectArray array, jsize index,
  1599.                    jobject val) {
  1600.         functions->SetObjectArrayElement(this,array,index,val);
  1601.     }
  1602.  
  1603.     jbooleanArray NewBooleanArray(jsize len) {
  1604.         return functions->NewBooleanArray(this,len);
  1605.     }
  1606.     jbyteArray NewByteArray(jsize len) {
  1607.         return functions->NewByteArray(this,len);
  1608.     }
  1609.     jcharArray NewCharArray(jsize len) {
  1610.         return functions->NewCharArray(this,len);
  1611.     }
  1612.     jshortArray NewShortArray(jsize len) {
  1613.         return functions->NewShortArray(this,len);
  1614.     }
  1615.     jintArray NewIntArray(jsize len) {
  1616.         return functions->NewIntArray(this,len);
  1617.     }
  1618.     jlongArray NewLongArray(jsize len) {
  1619.         return functions->NewLongArray(this,len);
  1620.     }
  1621.     jfloatArray NewFloatArray(jsize len) {
  1622.         return functions->NewFloatArray(this,len);
  1623.     }
  1624.     jdoubleArray NewDoubleArray(jsize len) {
  1625.         return functions->NewDoubleArray(this,len);
  1626.     }
  1627.  
  1628.     jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
  1629.         return functions->GetBooleanArrayElements(this,array,isCopy);
  1630.     }
  1631.     jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
  1632.         return functions->GetByteArrayElements(this,array,isCopy);
  1633.     }
  1634.     jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
  1635.         return functions->GetCharArrayElements(this,array,isCopy);
  1636.     }
  1637.     jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
  1638.         return functions->GetShortArrayElements(this,array,isCopy);
  1639.     }
  1640.     jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
  1641.         return functions->GetIntArrayElements(this,array,isCopy);
  1642.     }
  1643.     jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
  1644.         return functions->GetLongArrayElements(this,array,isCopy);
  1645.     }
  1646.     jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
  1647.         return functions->GetFloatArrayElements(this,array,isCopy);
  1648.     }
  1649.     jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
  1650.         return functions->GetDoubleArrayElements(this,array,isCopy);
  1651.     }
  1652.  
  1653.     void ReleaseBooleanArrayElements(jbooleanArray array,
  1654.                      jboolean *elems,
  1655.                      jint mode) {
  1656.         functions->ReleaseBooleanArrayElements(this,array,elems,mode);
  1657.     }
  1658.     void ReleaseByteArrayElements(jbyteArray array,
  1659.                   jbyte *elems,
  1660.                   jint mode) {
  1661.         functions->ReleaseByteArrayElements(this,array,elems,mode);
  1662.     }
  1663.     void ReleaseCharArrayElements(jcharArray array,
  1664.                   jchar *elems,
  1665.                   jint mode) {
  1666.         functions->ReleaseCharArrayElements(this,array,elems,mode);
  1667.     }
  1668.     void ReleaseShortArrayElements(jshortArray array,
  1669.                    jshort *elems,
  1670.                    jint mode) {
  1671.         functions->ReleaseShortArrayElements(this,array,elems,mode);
  1672.     }
  1673.     void ReleaseIntArrayElements(jintArray array,
  1674.                  jint *elems,
  1675.                  jint mode) {
  1676.         functions->ReleaseIntArrayElements(this,array,elems,mode);
  1677.     }
  1678.     void ReleaseLongArrayElements(jlongArray array,
  1679.                   jlong *elems,
  1680.                   jint mode) {
  1681.         functions->ReleaseLongArrayElements(this,array,elems,mode);
  1682.     }
  1683.     void ReleaseFloatArrayElements(jfloatArray array,
  1684.                    jfloat *elems,
  1685.                    jint mode) {
  1686.         functions->ReleaseFloatArrayElements(this,array,elems,mode);
  1687.     }
  1688.     void ReleaseDoubleArrayElements(jdoubleArray array,
  1689.                     jdouble *elems,
  1690.                     jint mode) {
  1691.         functions->ReleaseDoubleArrayElements(this,array,elems,mode);
  1692.     }
  1693.  
  1694.     void GetBooleanArrayRegion(jbooleanArray array,
  1695.                    jsize start, jsize len, jboolean *buf) {
  1696.         functions->GetBooleanArrayRegion(this,array,start,len,buf);
  1697.     }
  1698.     void GetByteArrayRegion(jbyteArray array,
  1699.                 jsize start, jsize len, jbyte *buf) {
  1700.         functions->GetByteArrayRegion(this,array,start,len,buf);
  1701.     }
  1702.     void GetCharArrayRegion(jcharArray array,
  1703.                 jsize start, jsize len, jchar *buf) {
  1704.         functions->GetCharArrayRegion(this,array,start,len,buf);
  1705.     }
  1706.     void GetShortArrayRegion(jshortArray array,
  1707.                  jsize start, jsize len, jshort *buf) {
  1708.         functions->GetShortArrayRegion(this,array,start,len,buf);
  1709.     }
  1710.     void GetIntArrayRegion(jintArray array,
  1711.                jsize start, jsize len, jint *buf) {
  1712.         functions->GetIntArrayRegion(this,array,start,len,buf);
  1713.     }
  1714.     void GetLongArrayRegion(jlongArray array,
  1715.                 jsize start, jsize len, jlong *buf) {
  1716.         functions->GetLongArrayRegion(this,array,start,len,buf);
  1717.     }
  1718.     void GetFloatArrayRegion(jfloatArray array,
  1719.                  jsize start, jsize len, jfloat *buf) {
  1720.         functions->GetFloatArrayRegion(this,array,start,len,buf);
  1721.     }
  1722.     void GetDoubleArrayRegion(jdoubleArray array,
  1723.                   jsize start, jsize len, jdouble *buf) {
  1724.         functions->GetDoubleArrayRegion(this,array,start,len,buf);
  1725.     }
  1726.  
  1727.     void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
  1728.                    jboolean *buf) {
  1729.         functions->SetBooleanArrayRegion(this,array,start,len,buf);
  1730.     }
  1731.     void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
  1732.                 jbyte *buf) {
  1733.         functions->SetByteArrayRegion(this,array,start,len,buf);
  1734.     }
  1735.     void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
  1736.                 jchar *buf) {
  1737.         functions->SetCharArrayRegion(this,array,start,len,buf);
  1738.     }
  1739.     void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
  1740.                  jshort *buf) {
  1741.         functions->SetShortArrayRegion(this,array,start,len,buf);
  1742.     }
  1743.     void SetIntArrayRegion(jintArray array, jsize start, jsize len,
  1744.                jint *buf) {
  1745.         functions->SetIntArrayRegion(this,array,start,len,buf);
  1746.     }
  1747.     void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
  1748.                 jlong *buf) {
  1749.         functions->SetLongArrayRegion(this,array,start,len,buf);
  1750.     }
  1751.     void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
  1752.                  jfloat *buf) {
  1753.         functions->SetFloatArrayRegion(this,array,start,len,buf);
  1754.     }
  1755.     void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
  1756.                   jdouble *buf) {
  1757.         functions->SetDoubleArrayRegion(this,array,start,len,buf);
  1758.     }
  1759.  
  1760.     jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
  1761.              jint nMethods) {
  1762.         return functions->RegisterNatives(this,clazz,methods,nMethods);
  1763.     }
  1764.     jint UnregisterNatives(jclass clazz) {
  1765.         return functions->UnregisterNatives(this,clazz);
  1766.     }
  1767.  
  1768.     jint MonitorEnter(jobject obj) {
  1769.         return functions->MonitorEnter(this,obj);
  1770.     }
  1771.     jint MonitorExit(jobject obj) {
  1772.         return functions->MonitorExit(this,obj);
  1773.     }
  1774.  
  1775.     jint GetJavaVM(JavaVM **vm) {
  1776.         return functions->GetJavaVM(this,vm);
  1777.     }
  1778.  
  1779.     void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
  1780.         functions->GetStringRegion(this,str,start,len,buf);
  1781.     }
  1782.     void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
  1783.         functions->GetStringUTFRegion(this,str,start,len,buf);
  1784.     }
  1785.  
  1786.     void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
  1787.         return functions->GetPrimitiveArrayCritical(this,array,isCopy);
  1788.     }
  1789.     void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
  1790.         functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
  1791.     }
  1792.  
  1793.     const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
  1794.         return functions->GetStringCritical(this,string,isCopy);
  1795.     }
  1796.     void ReleaseStringCritical(jstring string, const jchar *cstring) {
  1797.         functions->ReleaseStringCritical(this,string,cstring);
  1798.     }
  1799.  
  1800.     jweak NewWeakGlobalRef(jobject obj) {
  1801.         return functions->NewWeakGlobalRef(this,obj);
  1802.     }
  1803.     void DeleteWeakGlobalRef(jweak ref) {
  1804.         functions->DeleteWeakGlobalRef(this,ref);
  1805.     }
  1806.  
  1807.     jboolean ExceptionCheck() {
  1808.     return functions->ExceptionCheck(this);
  1809.     }
  1810.  
  1811. #endif /* __cplusplus */
  1812. };
  1813.  
  1814. typedef struct JavaVMOption {
  1815.     char *optionString;
  1816.     void *extraInfo;
  1817. } JavaVMOption;
  1818.  
  1819. typedef struct JavaVMInitArgs {
  1820.     jint version;
  1821.  
  1822.     jint nOptions;
  1823.     JavaVMOption *options;
  1824.     jboolean ignoreUnrecognized;
  1825. } JavaVMInitArgs;
  1826.  
  1827. typedef struct JavaVMAttachArgs {
  1828.     jint version;
  1829.  
  1830.     char *name;
  1831.     jobject group;
  1832. } JavaVMAttachArgs;
  1833.  
  1834. /* These structures will be VM-specific. */
  1835.  
  1836. typedef struct JDK1_1InitArgs {
  1837.     jint version;
  1838.  
  1839.     char **properties;
  1840.     jint checkSource;
  1841.     jint nativeStackSize;
  1842.     jint javaStackSize;
  1843.     jint minHeapSize;
  1844.     jint maxHeapSize;
  1845.     jint verifyMode;
  1846.     char *classpath;
  1847.  
  1848.     jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
  1849.     void (JNICALL *exit)(jint code);
  1850.     void (JNICALL *abort)(void);
  1851.  
  1852.     jint enableClassGC;
  1853.     jint enableVerboseGC;
  1854.     jint disableAsyncGC;
  1855.     jint verbose;
  1856.     jboolean debugging;
  1857.     jint debugPort;
  1858. } JDK1_1InitArgs;
  1859.  
  1860. typedef struct JDK1_1AttachArgs {
  1861.     void * __padding; /* C compilers don't allow empty structures. */
  1862. } JDK1_1AttachArgs;
  1863.  
  1864. #define JDK1_2
  1865.  
  1866. /* End VM-specific. */
  1867.  
  1868. struct JNIInvokeInterface_ {
  1869.     void *reserved0;
  1870.     void *reserved1;
  1871.     void *reserved2;
  1872.  
  1873.     jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
  1874.  
  1875.     jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
  1876.  
  1877.     jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
  1878.  
  1879.     jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
  1880. };
  1881.  
  1882. struct JavaVM_ {
  1883.     const struct JNIInvokeInterface_ *functions;
  1884. #ifdef __cplusplus
  1885.  
  1886.     jint DestroyJavaVM() {
  1887.         return functions->DestroyJavaVM(this);
  1888.     }
  1889.     jint AttachCurrentThread(void **penv, void *args) {
  1890.         return functions->AttachCurrentThread(this, penv, args);
  1891.     }
  1892.     jint DetachCurrentThread() {
  1893.         return functions->DetachCurrentThread(this);
  1894.     }
  1895.  
  1896.     jint GetEnv(void **penv, jint version) {
  1897.         return functions->GetEnv(this, penv, version);
  1898.     }
  1899. #endif
  1900. };
  1901.  
  1902. #ifdef _JNI_IMPLEMENTATION_
  1903. #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
  1904. #else
  1905. #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
  1906. #endif
  1907. _JNI_IMPORT_OR_EXPORT_ jint JNICALL
  1908. JNI_GetDefaultJavaVMInitArgs(void *args);
  1909.  
  1910. _JNI_IMPORT_OR_EXPORT_ jint JNICALL
  1911. JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
  1912.  
  1913. _JNI_IMPORT_OR_EXPORT_ jint JNICALL
  1914. JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
  1915.  
  1916. /* Defined by native libraries. */
  1917. JNIEXPORT jint JNICALL
  1918. JNI_OnLoad(JavaVM *vm, void *reserved);
  1919.  
  1920. JNIEXPORT void JNICALL
  1921. JNI_OnUnload(JavaVM *vm, void *reserved);
  1922.  
  1923. #define JNI_VERSION_1_1 0x00010001
  1924. #define JNI_VERSION_1_2 0x00010002
  1925.  
  1926. #ifdef __cplusplus
  1927. } /* extern "C" */
  1928. #endif /* __cplusplus */
  1929.  
  1930. #endif /* !_JAVASOFT_JNI_H_ */
  1931.  
  1932.  
  1933.